// Machine generated IDispatch wrapper class(es) created with ClassWizard
/////////////////////////////////////////////////////////////////////////////
// ISpeechDataKey wrapper class

class ISpeechDataKey : public COleDispatchDriver
{
public:
	ISpeechDataKey() {}		// Calls COleDispatchDriver default constructor
	ISpeechDataKey(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechDataKey(const ISpeechDataKey& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void SetBinaryValue(LPCTSTR ValueName, const VARIANT& Value);
	VARIANT GetBinaryValue(LPCTSTR ValueName);
	void SetStringValue(LPCTSTR ValueName, LPCTSTR Value);
	CString GetStringValue(LPCTSTR ValueName);
	void SetLongValue(LPCTSTR ValueName, long Value);
	long GetLongValue(LPCTSTR ValueName);
	LPDISPATCH OpenKey(LPCTSTR SubKeyName);
	LPDISPATCH CreateKey(LPCTSTR SubKeyName);
	void DeleteKey(LPCTSTR SubKeyName);
	void DeleteValue(LPCTSTR ValueName);
	CString EnumKeys(long Index);
	CString EnumValues(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectToken wrapper class

class ISpeechObjectToken : public COleDispatchDriver
{
public:
	ISpeechObjectToken() {}		// Calls COleDispatchDriver default constructor
	ISpeechObjectToken(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechObjectToken(const ISpeechObjectToken& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetId();
	LPDISPATCH GetCategory();
	CString GetDescription(long Locale);
	CString GetAttribute(LPCTSTR AttributeName);
	LPUNKNOWN CreateInstance(LPUNKNOWN pUnkOuter, long ClsContext);
	BOOL MatchesAttributes(LPCTSTR Attributes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokenCategory wrapper class

class ISpeechObjectTokenCategory : public COleDispatchDriver
{
public:
	ISpeechObjectTokenCategory() {}		// Calls COleDispatchDriver default constructor
	ISpeechObjectTokenCategory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechObjectTokenCategory(const ISpeechObjectTokenCategory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetId();
	void SetDefault(LPCTSTR lpszNewValue);
	CString GetDefault();
	void SetId(LPCTSTR Id, BOOL CreateIfNotExist);
	LPDISPATCH EnumerateTokens(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokens wrapper class

class ISpeechObjectTokens : public COleDispatchDriver
{
public:
	ISpeechObjectTokens() {}		// Calls COleDispatchDriver default constructor
	ISpeechObjectTokens(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechObjectTokens(const ISpeechObjectTokens& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioBufferInfo wrapper class

class ISpeechAudioBufferInfo : public COleDispatchDriver
{
public:
	ISpeechAudioBufferInfo() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudioBufferInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudioBufferInfo(const ISpeechAudioBufferInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetMinNotification();
	void SetMinNotification(long nNewValue);
	long GetBufferSize();
	void SetBufferSize(long nNewValue);
	long GetEventBias();
	void SetEventBias(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioStatus wrapper class

class ISpeechAudioStatus : public COleDispatchDriver
{
public:
	ISpeechAudioStatus() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudioStatus(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudioStatus(const ISpeechAudioStatus& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetFreeBufferSpace();
	long GetNonBlockingIO();
	long GetState();
	VARIANT GetCurrentSeekPosition();
	VARIANT GetCurrentDevicePosition();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioFormat wrapper class

class ISpeechAudioFormat : public COleDispatchDriver
{
public:
	ISpeechAudioFormat() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudioFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudioFormat(const ISpeechAudioFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetType();
	void SetType(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechWaveFormatEx wrapper class

class ISpeechWaveFormatEx : public COleDispatchDriver
{
public:
	ISpeechWaveFormatEx() {}		// Calls COleDispatchDriver default constructor
	ISpeechWaveFormatEx(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechWaveFormatEx(const ISpeechWaveFormatEx& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	short GetFormatTag();
	void SetFormatTag(short nNewValue);
	short GetChannels();
	void SetChannels(short nNewValue);
	long GetSamplesPerSec();
	void SetSamplesPerSec(long nNewValue);
	long GetAvgBytesPerSec();
	void SetAvgBytesPerSec(long nNewValue);
	short GetBlockAlign();
	void SetBlockAlign(short nNewValue);
	short GetBitsPerSample();
	void SetBitsPerSample(short nNewValue);
	VARIANT GetExtraData();
	void SetExtraData(const VARIANT& newValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechBaseStream wrapper class

class ISpeechBaseStream : public COleDispatchDriver
{
public:
	ISpeechBaseStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechBaseStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechBaseStream(const ISpeechBaseStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechFileStream wrapper class

class ISpeechFileStream : public COleDispatchDriver
{
public:
	ISpeechFileStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechFileStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechFileStream(const ISpeechFileStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	void Open(LPCTSTR FileName, long FileMode, BOOL DoEvents);
	void Close();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechMemoryStream wrapper class

class ISpeechMemoryStream : public COleDispatchDriver
{
public:
	ISpeechMemoryStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechMemoryStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechMemoryStream(const ISpeechMemoryStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	void SetData(const VARIANT& Data);
	VARIANT GetData();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechCustomStream wrapper class

class ISpeechCustomStream : public COleDispatchDriver
{
public:
	ISpeechCustomStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechCustomStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechCustomStream(const ISpeechCustomStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	LPUNKNOWN GetBaseStream();
	void SetRefBaseStream(LPUNKNOWN newValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudio wrapper class

class ISpeechAudio : public COleDispatchDriver
{
public:
	ISpeechAudio() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudio(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudio(const ISpeechAudio& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	LPDISPATCH GetStatus();
	LPDISPATCH GetBufferInfo();
	LPDISPATCH GetDefaultFormat();
	long GetVolume();
	void SetVolume(long nNewValue);
	long GetBufferNotifySize();
	void SetBufferNotifySize(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechMMSysAudio wrapper class

class ISpeechMMSysAudio : public COleDispatchDriver
{
public:
	ISpeechMMSysAudio() {}		// Calls COleDispatchDriver default constructor
	ISpeechMMSysAudio(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechMMSysAudio(const ISpeechMMSysAudio& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	LPDISPATCH GetStatus();
	LPDISPATCH GetBufferInfo();
	LPDISPATCH GetDefaultFormat();
	long GetVolume();
	void SetVolume(long nNewValue);
	long GetBufferNotifySize();
	void SetBufferNotifySize(long nNewValue);
	long GetDeviceId();
	void SetDeviceId(long nNewValue);
	long GetLineId();
	void SetLineId(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechVoice wrapper class

class ISpeechVoice : public COleDispatchDriver
{
public:
	ISpeechVoice() {}		// Calls COleDispatchDriver default constructor
	ISpeechVoice(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechVoice(const ISpeechVoice& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetStatus();
	LPDISPATCH GetVoice();
	void SetRefVoice(LPDISPATCH newValue);
	LPDISPATCH GetAudioOutput();
	void SetRefAudioOutput(LPDISPATCH newValue);
	LPDISPATCH GetAudioOutputStream();
	void SetRefAudioOutputStream(LPDISPATCH newValue);
	long GetRate();
	void SetRate(long nNewValue);
	long GetVolume();
	void SetVolume(long nNewValue);
	long GetEventInterests();
	void SetEventInterests(long nNewValue);
	void SetPriority(long nNewValue);
	long GetPriority();
	void SetAlertBoundary(long nNewValue);
	long GetAlertBoundary();
	void SetSynchronousSpeakTimeout(long nNewValue);
	long GetSynchronousSpeakTimeout();
	long Speak(LPCTSTR Text, long Flags);
	long SpeakStream(LPDISPATCH Stream, long Flags);
	void Pause();
	void Resume();
	long Skip(LPCTSTR Type, long NumItems);
	LPDISPATCH GetVoices(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	LPDISPATCH GetAudioOutputs(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	BOOL WaitUntilDone(long msTimeout);
	BOOL IsUISupported(LPCTSTR TypeOfUI, VARIANT* ExtraData);
	void DisplayUI(long hWndParent, LPCTSTR Title, LPCTSTR TypeOfUI, VARIANT* ExtraData);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechVoiceStatus wrapper class

class ISpeechVoiceStatus : public COleDispatchDriver
{
public:
	ISpeechVoiceStatus() {}		// Calls COleDispatchDriver default constructor
	ISpeechVoiceStatus(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechVoiceStatus(const ISpeechVoiceStatus& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCurrentStreamNumber();
	long GetLastStreamNumberQueued();
	long GetLastHResult();
	long GetRunningState();
	long GetInputWordPosition();
	long GetInputWordLength();
	long GetInputSentencePosition();
	long GetInputSentenceLength();
	CString GetLastBookmark();
	short GetPhonemeId();
	short GetVisemeId();
};
/////////////////////////////////////////////////////////////////////////////
// _ISpeechVoiceEvents wrapper class

class _ISpeechVoiceEvents : public COleDispatchDriver
{
public:
	_ISpeechVoiceEvents() {}		// Calls COleDispatchDriver default constructor
	_ISpeechVoiceEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	_ISpeechVoiceEvents(const _ISpeechVoiceEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void StartStream(long StreamNumber, const VARIANT& StreamPosition);
	void EndStream(long StreamNumber, const VARIANT& StreamPosition);
	void VoiceChange(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH VoiceObjectToken);
	void Bookmark(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR Bookmark, long BookmarkId);
	void Word(long StreamNumber, const VARIANT& StreamPosition, long CharacterPosition, long Length);
	void Sentence(long StreamNumber, const VARIANT& StreamPosition, long CharacterPosition, long Length);
	void Phoneme(long StreamNumber, const VARIANT& StreamPosition, long Duration, short NextPhoneId, long Feature, short CurrentPhoneId);
	void Viseme(long StreamNumber, const VARIANT& StreamPosition, long Duration, long NextVisemeId, long Feature, long CurrentVisemeId);
	void AudioLevel(long StreamNumber, const VARIANT& StreamPosition, long AudioLevel);
	void EnginePrivate(long StreamNumber, long StreamPosition, const VARIANT& EngineData);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizer wrapper class

class ISpeechRecognizer : public COleDispatchDriver
{
public:
	ISpeechRecognizer() {}		// Calls COleDispatchDriver default constructor
	ISpeechRecognizer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechRecognizer(const ISpeechRecognizer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void SetRefRecognizer(LPDISPATCH newValue);
	LPDISPATCH GetRecognizer();
	void SetRefAudioInput(LPDISPATCH newValue);
	LPDISPATCH GetAudioInput();
	void SetRefAudioInputStream(LPDISPATCH newValue);
	LPDISPATCH GetAudioInputStream();
	BOOL GetIsShared();
	void SetState(long nNewValue);
	long GetState();
	LPDISPATCH GetStatus();
	void SetRefProfile(LPDISPATCH newValue);
	LPDISPATCH GetProfile();
	void EmulateRecognition(const VARIANT& TextElements, VARIANT* ElementDisplayAttributes, long LanguageId);
	LPDISPATCH CreateRecoContext();
	LPDISPATCH GetFormat(long Type);
	BOOL IsUISupported(LPCTSTR TypeOfUI, VARIANT* ExtraData);
	void DisplayUI(long hWndParent, LPCTSTR Title, LPCTSTR TypeOfUI, VARIANT* ExtraData);
	LPDISPATCH GetRecognizers(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	LPDISPATCH GetAudioInputs(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	LPDISPATCH GetProfiles(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizerStatus wrapper class

class ISpeechRecognizerStatus : public COleDispatchDriver
{
public:
	ISpeechRecognizerStatus() {}		// Calls COleDispatchDriver default constructor
	ISpeechRecognizerStatus(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechRecognizerStatus(const ISpeechRecognizerStatus& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetAudioStatus();
	VARIANT GetCurrentStreamPosition();
	long GetCurrentStreamNumber();
	long GetNumberOfActiveRules();
	CString GetClsidEngine();
	VARIANT GetSupportedLanguages();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoContext wrapper class

class ISpeechRecoContext : public COleDispatchDriver
{
public:
	ISpeechRecoContext() {}		// Calls COleDispatchDriver default constructor
	ISpeechRecoContext(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechRecoContext(const ISpeechRecoContext& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetRecognizer();
	long GetAudioInputInterferenceStatus();
	CString GetRequestedUIType();
	void SetRefVoice(LPDISPATCH newValue);
	LPDISPATCH GetVoice();
	void SetVoicePurgeEvent(long nNewValue);
	long GetVoicePurgeEvent();
	void SetEventInterests(long nNewValue);
	long GetEventInterests();
	void SetCmdMaxAlternates(long nNewValue);
	long GetCmdMaxAlternates();
	void SetState(long nNewValue);
	long GetState();
	void SetRetainedAudio(long nNewValue);
	long GetRetainedAudio();
	void SetRefRetainedAudioFormat(LPDISPATCH newValue);
	LPDISPATCH GetRetainedAudioFormat();
	void Pause();
	void Resume();
	LPDISPATCH CreateGrammar(const VARIANT& GrammarId);
	LPDISPATCH CreateResultFromMemory(VARIANT* ResultBlock);
	void Bookmark(long Options, const VARIANT& StreamPos, const VARIANT& BookmarkId);
	void SetAdaptationData(LPCTSTR AdaptationString);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoGrammar wrapper class

class ISpeechRecoGrammar : public COleDispatchDriver
{
public:
	ISpeechRecoGrammar() {}		// Calls COleDispatchDriver default constructor
	ISpeechRecoGrammar(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechRecoGrammar(const ISpeechRecoGrammar& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	VARIANT GetId();
	LPDISPATCH GetRecoContext();
	void SetState(long nNewValue);
	long GetState();
	LPDISPATCH GetRules();
	void Reset(long NewLanguage);
	void CmdLoadFromFile(LPCTSTR FileName, long LoadOption);
	void CmdLoadFromObject(LPCTSTR ClassId, LPCTSTR GrammarName, long LoadOption);
	void CmdLoadFromResource(long hModule, const VARIANT& ResourceName, const VARIANT& ResourceType, long LanguageId, long LoadOption);
	void CmdLoadFromMemory(const VARIANT& GrammarData, long LoadOption);
	void CmdLoadFromProprietaryGrammar(LPCTSTR ProprietaryGuid, LPCTSTR ProprietaryString, const VARIANT& ProprietaryData, long LoadOption);
	void CmdSetRuleState(LPCTSTR Name, long State);
	void CmdSetRuleIdState(long RuleId, long State);
	void DictationLoad(LPCTSTR TopicName, long LoadOption);
	void DictationUnload();
	void DictationSetState(long State);
	void SetWordSequenceData(LPCTSTR Text, long TextLength, LPDISPATCH Info);
	void SetTextSelection(LPDISPATCH Info);
	long IsPronounceable(LPCTSTR Word);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRules wrapper class

class ISpeechGrammarRules : public COleDispatchDriver
{
public:
	ISpeechGrammarRules() {}		// Calls COleDispatchDriver default constructor
	ISpeechGrammarRules(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechGrammarRules(const ISpeechGrammarRules& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH FindRule(const VARIANT& RuleNameOrId);
	LPDISPATCH Item(long Index);
	BOOL GetDynamic();
	LPDISPATCH Add(LPCTSTR RuleName, long Attributes, long RuleId);
	void Commit();
	VARIANT CommitAndSave(BSTR* ErrorText);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRule wrapper class

class ISpeechGrammarRule : public COleDispatchDriver
{
public:
	ISpeechGrammarRule() {}		// Calls COleDispatchDriver default constructor
	ISpeechGrammarRule(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechGrammarRule(const ISpeechGrammarRule& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetAttributes();
	LPDISPATCH GetInitialState();
	CString GetName();
	long GetId();
	void Clear();
	void AddResource(LPCTSTR ResourceName, LPCTSTR ResourceValue);
	LPDISPATCH AddState();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleState wrapper class

class ISpeechGrammarRuleState : public COleDispatchDriver
{
public:
	ISpeechGrammarRuleState() {}		// Calls COleDispatchDriver default constructor
	ISpeechGrammarRuleState(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechGrammarRuleState(const ISpeechGrammarRuleState& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetRule();
	LPDISPATCH GetTransitions();
	void AddWordTransition(LPDISPATCH DestState, LPCTSTR Words, LPCTSTR Separators, long Type, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight);
	void AddRuleTransition(LPDISPATCH DestinationState, LPDISPATCH Rule, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight);
	void AddSpecialTransition(LPDISPATCH DestinationState, long Type, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleStateTransitions wrapper class

class ISpeechGrammarRuleStateTransitions : public COleDispatchDriver
{
public:
	ISpeechGrammarRuleStateTransitions() {}		// Calls COleDispatchDriver default constructor
	ISpeechGrammarRuleStateTransitions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechGrammarRuleStateTransitions(const ISpeechGrammarRuleStateTransitions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleStateTransition wrapper class

class ISpeechGrammarRuleStateTransition : public COleDispatchDriver
{
public:
	ISpeechGrammarRuleStateTransition() {}		// Calls COleDispatchDriver default constructor
	ISpeechGrammarRuleStateTransition(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechGrammarRuleStateTransition(const ISpeechGrammarRuleStateTransition& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetType();
	CString GetText();
	LPDISPATCH GetRule();
	VARIANT GetWeight();
	CString GetPropertyName();
	long GetPropertyId();
	VARIANT GetPropertyValue();
	LPDISPATCH GetNextState();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechTextSelectionInformation wrapper class

class ISpeechTextSelectionInformation : public COleDispatchDriver
{
public:
	ISpeechTextSelectionInformation() {}		// Calls COleDispatchDriver default constructor
	ISpeechTextSelectionInformation(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechTextSelectionInformation(const ISpeechTextSelectionInformation& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void SetActiveOffset(long nNewValue);
	long GetActiveOffset();
	void SetActiveLength(long nNewValue);
	long GetActiveLength();
	void SetSelectionOffset(long nNewValue);
	long GetSelectionOffset();
	void SetSelectionLength(long nNewValue);
	long GetSelectionLength();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResult wrapper class

class ISpeechRecoResult : public COleDispatchDriver
{
public:
	ISpeechRecoResult() {}		// Calls COleDispatchDriver default constructor
	ISpeechRecoResult(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechRecoResult(const ISpeechRecoResult& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetRecoContext();
	LPDISPATCH GetTimes();
	void SetRefAudioFormat(LPDISPATCH newValue);
	LPDISPATCH GetAudioFormat();
	LPDISPATCH GetPhraseInfo();
	LPDISPATCH Alternates(long RequestCount, long StartElement, long Elements);
	LPDISPATCH Audio(long StartElement, long Elements);
	long SpeakAudio(long StartElement, long Elements, long Flags);
	VARIANT SaveToMemory();
	void DiscardResultInfo(long ValueTypes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResultTimes wrapper class

class ISpeechRecoResultTimes : public COleDispatchDriver
{
public:
	ISpeechRecoResultTimes() {}		// Calls COleDispatchDriver default constructor
	ISpeechRecoResultTimes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechRecoResultTimes(const ISpeechRecoResultTimes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	VARIANT GetStreamTime();
	VARIANT GetLength();
	long GetTickCount();
	VARIANT GetOffsetFromStart();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseInfo wrapper class

class ISpeechPhraseInfo : public COleDispatchDriver
{
public:
	ISpeechPhraseInfo() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseInfo(const ISpeechPhraseInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetLanguageId();
	VARIANT GetGrammarId();
	VARIANT GetStartTime();
	VARIANT GetAudioStreamPosition();
	long GetAudioSizeBytes();
	long GetRetainedSizeBytes();
	long GetAudioSizeTime();
	LPDISPATCH GetRule();
	LPDISPATCH GetProperties();
	LPDISPATCH GetElements();
	LPDISPATCH GetReplacements();
	CString GetEngineId();
	VARIANT GetEnginePrivateData();
	VARIANT SaveToMemory();
	CString GetText(long StartElement, long Elements, BOOL UseReplacements);
	long GetDisplayAttributes(long StartElement, long Elements, BOOL UseReplacements);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseRule wrapper class

class ISpeechPhraseRule : public COleDispatchDriver
{
public:
	ISpeechPhraseRule() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseRule(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseRule(const ISpeechPhraseRule& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetName();
	long GetId();
	long GetFirstElement();
	long GetNumberOfElements();
	LPDISPATCH GetParent();
	LPDISPATCH GetChildren();
	long GetConfidence();
	float GetEngineConfidence();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseRules wrapper class

class ISpeechPhraseRules : public COleDispatchDriver
{
public:
	ISpeechPhraseRules() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseRules(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseRules(const ISpeechPhraseRules& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseProperties wrapper class

class ISpeechPhraseProperties : public COleDispatchDriver
{
public:
	ISpeechPhraseProperties() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseProperties(const ISpeechPhraseProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseProperty wrapper class

class ISpeechPhraseProperty : public COleDispatchDriver
{
public:
	ISpeechPhraseProperty() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseProperty(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseProperty(const ISpeechPhraseProperty& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetName();
	long GetId();
	VARIANT GetValue();
	long GetFirstElement();
	long GetNumberOfElements();
	float GetEngineConfidence();
	long GetConfidence();
	LPDISPATCH GetParent();
	LPDISPATCH GetChildren();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseElements wrapper class

class ISpeechPhraseElements : public COleDispatchDriver
{
public:
	ISpeechPhraseElements() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseElements(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseElements(const ISpeechPhraseElements& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseElement wrapper class

class ISpeechPhraseElement : public COleDispatchDriver
{
public:
	ISpeechPhraseElement() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseElement(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseElement(const ISpeechPhraseElement& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetAudioTimeOffset();
	long GetAudioSizeTime();
	long GetAudioStreamOffset();
	long GetAudioSizeBytes();
	long GetRetainedStreamOffset();
	long GetRetainedSizeBytes();
	CString GetDisplayText();
	CString GetLexicalForm();
	VARIANT GetPronunciation();
	long GetDisplayAttributes();
	long GetRequiredConfidence();
	long GetActualConfidence();
	float GetEngineConfidence();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseReplacements wrapper class

class ISpeechPhraseReplacements : public COleDispatchDriver
{
public:
	ISpeechPhraseReplacements() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseReplacements(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseReplacements(const ISpeechPhraseReplacements& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseReplacement wrapper class

class ISpeechPhraseReplacement : public COleDispatchDriver
{
public:
	ISpeechPhraseReplacement() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseReplacement(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseReplacement(const ISpeechPhraseReplacement& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetDisplayAttributes();
	CString GetText();
	long GetFirstElement();
	long GetNumberOfElements();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseAlternates wrapper class

class ISpeechPhraseAlternates : public COleDispatchDriver
{
public:
	ISpeechPhraseAlternates() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseAlternates(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseAlternates(const ISpeechPhraseAlternates& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseAlternate wrapper class

class ISpeechPhraseAlternate : public COleDispatchDriver
{
public:
	ISpeechPhraseAlternate() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseAlternate(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseAlternate(const ISpeechPhraseAlternate& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetRecoResult();
	long GetStartElementInResult();
	long GetNumberOfElementsInResult();
	LPDISPATCH GetPhraseInfo();
	void Commit();
};
/////////////////////////////////////////////////////////////////////////////
// _ISpeechRecoContextEvents wrapper class

class _ISpeechRecoContextEvents : public COleDispatchDriver
{
public:
	_ISpeechRecoContextEvents() {}		// Calls COleDispatchDriver default constructor
	_ISpeechRecoContextEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	_ISpeechRecoContextEvents(const _ISpeechRecoContextEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void StartStream(long StreamNumber, const VARIANT& StreamPosition);
	void EndStream(long StreamNumber, const VARIANT& StreamPosition, BOOL StreamReleased);
	void Bookmark(long StreamNumber, const VARIANT& StreamPosition, const VARIANT& BookmarkId, long Options);
	void SoundStart(long StreamNumber, const VARIANT& StreamPosition);
	void SoundEnd(long StreamNumber, const VARIANT& StreamPosition);
	void PhraseStart(long StreamNumber, const VARIANT& StreamPosition);
	void Recognition(long StreamNumber, const VARIANT& StreamPosition, long RecognitionType, LPDISPATCH Result);
	void Hypothesis(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH Result);
	void PropertyNumberChange(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR PropertyName, long NewNumberValue);
	void PropertyStringChange(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR PropertyName, LPCTSTR NewStringValue);
	void FalseRecognition(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH Result);
	void Interference(long StreamNumber, const VARIANT& StreamPosition, long Interference);
	void RequestUI(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR UIType);
	void RecognizerStateChange(long StreamNumber, const VARIANT& StreamPosition, long NewState);
	void Adaptation(long StreamNumber, const VARIANT& StreamPosition);
	void RecognitionForOtherContext(long StreamNumber, const VARIANT& StreamPosition);
	void AudioLevel(long StreamNumber, const VARIANT& StreamPosition, long AudioLevel);
	void EnginePrivate(long StreamNumber, const VARIANT& StreamPosition, const VARIANT& EngineData);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechLexicon wrapper class

class ISpeechLexicon : public COleDispatchDriver
{
public:
	ISpeechLexicon() {}		// Calls COleDispatchDriver default constructor
	ISpeechLexicon(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechLexicon(const ISpeechLexicon& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetWords(long Flags, long* GenerationId);
	void AddPronunciation(LPCTSTR bstrWord, long LangId, long PartOfSpeech, LPCTSTR bstrPronunciation);
	void RemovePronunciation(LPCTSTR bstrWord, long LangId, long PartOfSpeech, LPCTSTR bstrPronunciation);
	LPDISPATCH GetPronunciations(LPCTSTR bstrWord, long LangId, long TypeFlags);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconWords wrapper class

class ISpeechLexiconWords : public COleDispatchDriver
{
public:
	ISpeechLexiconWords() {}		// Calls COleDispatchDriver default constructor
	ISpeechLexiconWords(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechLexiconWords(const ISpeechLexiconWords& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconWord wrapper class

class ISpeechLexiconWord : public COleDispatchDriver
{
public:
	ISpeechLexiconWord() {}		// Calls COleDispatchDriver default constructor
	ISpeechLexiconWord(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechLexiconWord(const ISpeechLexiconWord& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetLangId();
	long GetType();
	CString GetWord();
	LPDISPATCH GetPronunciations();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconPronunciations wrapper class

class ISpeechLexiconPronunciations : public COleDispatchDriver
{
public:
	ISpeechLexiconPronunciations() {}		// Calls COleDispatchDriver default constructor
	ISpeechLexiconPronunciations(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechLexiconPronunciations(const ISpeechLexiconPronunciations& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconPronunciation wrapper class

class ISpeechLexiconPronunciation : public COleDispatchDriver
{
public:
	ISpeechLexiconPronunciation() {}		// Calls COleDispatchDriver default constructor
	ISpeechLexiconPronunciation(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechLexiconPronunciation(const ISpeechLexiconPronunciation& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetType();
	long GetLangId();
	long GetPartOfSpeech();
	VARIANT GetPhoneIds();
	CString GetSymbolic();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseInfoBuilder wrapper class

class ISpeechPhraseInfoBuilder : public COleDispatchDriver
{
public:
	ISpeechPhraseInfoBuilder() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhraseInfoBuilder(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhraseInfoBuilder(const ISpeechPhraseInfoBuilder& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH RestorePhraseFromMemory(VARIANT* PhraseInMemory);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhoneConverter wrapper class

class ISpeechPhoneConverter : public COleDispatchDriver
{
public:
	ISpeechPhoneConverter() {}		// Calls COleDispatchDriver default constructor
	ISpeechPhoneConverter(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechPhoneConverter(const ISpeechPhoneConverter& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetLanguageId();
	void SetLanguageId(long nNewValue);
	VARIANT PhoneToId(LPCTSTR Phonemes);
	CString IdToPhone(const VARIANT& IdArray);
};
